import java.util.LinkedList;
import java.util.Scanner;

/**
 * 
 * 
 * 一种字符串压缩表示的解压
 * 
 * 题目描述

有一种简易压缩算法：针对全部由小写英文字母组成的字符串，将其中连续超过两个相同字母的部分压缩为连续个数加该字母，其他部分保持原样不变。

例如：字符串“aaabbccccd”经过压缩成为字符串“3abb4cd”。

请您编写解压函数，根据输入的字符串，判断其是否为合法压缩过的字符串，

若输入合法则输出解压缩后的字符串，否则输出字符串“!error”来报告错误。

输入描述
输入一行，为一个ASCII字符串，长度不会超过100字符，用例保证输出的字符串长度也不会超过100字符。

输出描述
若判断输入为合法的经过压缩后的字符串，则输出压缩前的字符串；

若输入不合法，则输出字符串“!error”。

用例
输入	4dff
输出	ddddff
说明	4d扩展为dddd，故解压后的字符串为ddddff。
输入	2dff
输出	!error
说明	两个d不需要压缩，故输入不合法。
输入	4d@A
输出	!error
说明	全部由小写英文字母组成的字符串压缩后不会出现特殊字符@和大写字母A，故输入不合法。

题目解析
本题主要考察字符串操作。

我们遍历输入的压缩串的每一个字符 c：

若 c 是数字，则此时
继续往后读取连续的数字字符，比如 "41dff"，当遍历第一个字符 c = '4' 时，我们继续往后读取完连续的数字，得到一个重复次数41
读取完重复次数后，继续读取一个字符，看是否为小写字母，若不是，则输入串不合法，若是，比如 "41dff" 中 41 后面的 'd'，则我们需要将 'd' 重复41次后拼接到结果串。
若 c 是小写字母，则是一个独立的小写字母，直接拼接到结果串即可。
若 c 是其他字符，则输入串不合法。
按上面逻辑，直到遍历完输入串。即可得到一个解压后的结束串。
 */

public class 一种字符串压缩表示的解压 {
    public static void main(String[] args) {
        

        try{

            Scanner scanner = new Scanner(System.in);

            //接收输入
            String inputStr = scanner.nextLine();

            //保存字符串拆分
            LinkedList<String> spiltList = new LinkedList<>();

            char[] inputCharArr = inputStr.toCharArray();
            int position = 0;
            //遍历字符串，将字符串转换成list处理，数字合并
            while(position < inputCharArr.length){

                char c = inputCharArr[position];
                //如果字符是数字
                if(Character.isDigit(c)){
                    StringBuilder builder = new StringBuilder();
                    builder.append(c);
                    //尝试找到挨着的数字
                    position++;
                    while(position < inputCharArr.length){

                        if(Character.isDigit(inputCharArr[position])){

                            builder.append(inputCharArr[position]);

                            position++;
                        } else{
                            spiltList.add(builder.toString());

                            break;
                        }
                    }
                }
                spiltList.add(""+inputCharArr[position]);

                position++;
            }

            //spiltList.stream().forEach(System.out::println);

            for(int i=0; i<spiltList.size(); i++){

                String subStr = spiltList.get(i);

                if(isDigit(subStr)){

                    int intValue = Integer.parseInt(subStr);
                    if(intValue < 3){

                        //数字小于 3
                        System.out.println("!error");

                        return;

                    } else{

                        //用数字后面的字符来替换数字
                        if(i < spiltList.size()-1){

                            spiltList.set(i, unzip(intValue, spiltList.get(i+1)));
                            spiltList.set(i+1, "");
                        }
                    }


                } else if(!isLowLetter(subStr)){

                    //不是小写字符
                    System.out.println("!error");

                    return;

                }
            }

            //输出
            spiltList.stream().forEach(System.out::printf);
            // for(String str : spiltList){
            //     System.out.print(str);
            // }

            System.out.print("\n");


            
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    private static boolean isDigit(String str){

        try{

            Integer.parseInt(str);

            return true;

        }catch(Exception e){
            //e.printStackTrace();
            return false;
        }
    }

    private static String unzip(int intValue, String str){

        StringBuilder builder = new StringBuilder();

        int k =0;
        while (k <intValue) {
        
            builder.append(str);

            k++;

        }

        return builder.toString();
    }

    private static boolean isLowLetter(String str){

        for(char c : str.toCharArray()){

            if(!Character.isLowerCase(c)){

                return false;
            }
        }

        return true;
    }
}
